{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2022-11-11 15:02:59--  https://ascend-professional-construction-dataset.obs.myhuaweicloud.com/deep-learning/fashion-mnist.zip\r\n",
      "Resolving ascend-professional-construction-dataset.obs.myhuaweicloud.com (ascend-professional-construction-dataset.obs.myhuaweicloud.com)... 49.4.112.113, 49.4.112.90, 121.36.121.44\r\n",
      "Connecting to ascend-professional-construction-dataset.obs.myhuaweicloud.com (ascend-professional-construction-dataset.obs.myhuaweicloud.com)|49.4.112.113|:443... connected.\r\n",
      "HTTP request sent, awaiting response... 200 OK\r\n",
      "Length: 30967845 (30M) [application/zip]\r\n",
      "Saving to: ‘fashion-mnist.zip’\r\n",
      "\r\n",
      "fashion-mnist.zip   100%[===================>]  29.53M  2.90MB/s    in 9.5s    \r\n",
      "\r\n",
      "2022-11-11 15:03:10 (3.11 MB/s) - ‘fashion-mnist.zip’ saved [30967845/30967845]\r\n",
      "\r\n",
      "Archive:  fashion-mnist.zip\r\n",
      "   creating: fashion-mnist/test/\r\n",
      "  inflating: fashion-mnist/test/t10k-images-idx3-ubyte  \r\n",
      "  inflating: fashion-mnist/test/t10k-labels-idx1-ubyte  \r\n",
      "   creating: fashion-mnist/train/\r\n",
      "  inflating: fashion-mnist/train/train-images-idx3-ubyte  \r\n",
      "  inflating: fashion-mnist/train/train-labels-idx1-ubyte  \r\n"
     ]
    }
   ],
   "source": [
    "#从OBS桶下载数据集\n",
    "!wget https://ascend-professional-construction-dataset.obs.myhuaweicloud.com/deep-learning/fashion-mnist.zip\n",
    "\n",
    "#解压文件\n",
    "!unzip fashion-mnist.zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [],
   "source": [
    "import os\n",
    "import struct\n",
    "import sys\n",
    "from easydict import EasyDict as edict\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "import mindspore\n",
    "import mindspore.dataset as ds\n",
    "import mindspore.nn as nn\n",
    "from mindspore import context\n",
    "from mindspore.nn.metrics import Accuracy\n",
    "from mindspore.train import Model\n",
    "from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor, TimeMonitor\n",
    "from mindspore import Tensor\n",
    "\n",
    "context.set_context(mode=context.GRAPH_MODE, device_target='GPU')"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "cfg = edict({\n",
    "    'train_size': 60000,  # 训练集大小\n",
    "    'test_size': 10000,  # 测试集大小\n",
    "    'channel': 1,  # 图片通道数\n",
    "    'image_height': 28,  # 图片高度\n",
    "    'image_width': 28,  # 图片宽度\n",
    "    'batch_size': 64,\n",
    "    'num_classes': 10,  # 分类类别\n",
    "    'lr': 0.001,  # 学习率\n",
    "    'epoch_size': 20,  # 训练次数\n",
    "    'data_dir_train': os.path.join('fashion-mnist', 'train'),\n",
    "    'data_dir_test': os.path.join('fashion-mnist', 'test'),\n",
    "})"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [],
   "source": [
    "def read_image(file_name):\n",
    "    '''\n",
    "    :param file_name: 文件路径\n",
    "    :return:  训练或者测试数据\n",
    "    如下是训练的图片的二进制格式\n",
    "    [offset] [type]          [value]          [description]\n",
    "    0000     32 bit integer  0x00000803(2051) magic number\n",
    "    0004     32 bit integer  60000            number of images\n",
    "    0008     32 bit integer  28               number of rows\n",
    "    0012     32 bit integer  28               number of columns\n",
    "    0016     unsigned byte   ??               pixel\n",
    "    0017     unsigned byte   ??               pixel\n",
    "    ........\n",
    "    xxxx     unsigned byte   ??               pixel\n",
    "    '''\n",
    "    file_handle = open(file_name, \"rb\")  # 以二进制打开文档\n",
    "    file_content = file_handle.read()  # 读取到缓冲区中\n",
    "    head = struct.unpack_from('>IIII', file_content, 0)  # 取前4个整数，返回一个元组\n",
    "    offset = struct.calcsize('>IIII')\n",
    "    imgNum = head[1]  # 图片数\n",
    "    width = head[2]  # 宽度\n",
    "    height = head[3]  # 高度\n",
    "    bits = imgNum * width * height  # data一共有60000*28*28个像素值\n",
    "    bitsString = '>' + str(bits) + 'B'  # fmt格式：'>47040000B'\n",
    "    imgs = struct.unpack_from(bitsString, file_content, offset)  # 取data数据，返回一个元组\n",
    "    imgs_array = np.array(imgs, np.float32).reshape((imgNum, width * height))  # 最后将读取的数据reshape成 【图片数，图片像素】二维数组\n",
    "    return imgs_array\n",
    "\n",
    "\n",
    "def read_label(file_name):\n",
    "    '''\n",
    "    :param file_name:\n",
    "    :return:\n",
    "    标签的格式如下：\n",
    "    [offset] [type]          [value]          [description]\n",
    "    0000     32 bit integer  0x00000801(2049) magic number (MSB first)\n",
    "    0004     32 bit integer  60000            number of items\n",
    "    0008     unsigned byte   ??               label\n",
    "    0009     unsigned byte   ??               label\n",
    "    ........\n",
    "    xxxx     unsigned byte   ??               label\n",
    "    The labels values are 0 to 9.\n",
    "    '''\n",
    "    file_handle = open(file_name, \"rb\")  # 以二进制打开文档\n",
    "    file_content = file_handle.read()  # 读取到缓冲区中\n",
    "    head = struct.unpack_from('>II', file_content, 0)  # 取前2个整数，返回一个元组\n",
    "    offset = struct.calcsize('>II')\n",
    "    labelNum = head[1]  # label数\n",
    "    bitsString = '>' + str(labelNum) + 'B'  # fmt格式：'>47040000B'\n",
    "    label = struct.unpack_from(bitsString, file_content, offset)  # 取data数据，返回一个元组\n",
    "    return np.array(label, np.int32)\n",
    "\n",
    "\n",
    "def get_data():\n",
    "    # 文件获取\n",
    "    train_image = os.path.join(cfg.data_dir_train, 'train-images-idx3-ubyte')\n",
    "    test_image = os.path.join(cfg.data_dir_test, \"t10k-images-idx3-ubyte\")\n",
    "    train_label = os.path.join(cfg.data_dir_train, \"train-labels-idx1-ubyte\")\n",
    "    test_label = os.path.join(cfg.data_dir_test, \"t10k-labels-idx1-ubyte\")\n",
    "    # 读取数据\n",
    "    train_x = read_image(train_image)\n",
    "    test_x = read_image(test_image)\n",
    "    train_y = read_label(train_label)\n",
    "    test_y = read_label(test_label)\n",
    "    return train_x, train_y, test_x, test_y"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练数据集样本数： 60000\n",
      "测试数据集样本数： 10000\n",
      "通道数/图像长/宽： (1, 28, 28)\n",
      "一张图像的标签样式： 9\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 2 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_x, train_y, test_x, test_y = get_data()\n",
    "train_x = train_x.reshape(-1, 1, cfg.image_height, cfg.image_width)\n",
    "test_x = test_x.reshape(-1, 1, cfg.image_height, cfg.image_width)\n",
    "train_x = train_x / 255.0\n",
    "test_x = test_x / 255.0\n",
    "\n",
    "print('训练数据集样本数：', train_x.shape[0])\n",
    "print('测试数据集样本数：', test_y.shape[0])\n",
    "print('通道数/图像长/宽：', train_x.shape[1:])\n",
    "print('一张图像的标签样式：', train_y[0])  # 一共10类，用0-9的数字表达类别。\n",
    "\n",
    "plt.figure()\n",
    "plt.imshow(train_x[0,0,...])\n",
    "plt.colorbar()\n",
    "plt.grid(False)\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [],
   "source": [
    "# 转换数据类型为Dataset\n",
    "def create_dataset():\n",
    "    XY_train = list(zip(train_x, train_y))\n",
    "    ds_train = ds.GeneratorDataset(XY_train, ['x', 'y'])\n",
    "    ds_train = ds_train.shuffle(buffer_size=1000).batch(cfg.batch_size, drop_remainder=True)\n",
    "    XY_test = list(zip(test_x, test_y))\n",
    "    ds_test = ds.GeneratorDataset(XY_test, ['x', 'y'])\n",
    "    ds_test = ds_test.shuffle(buffer_size=1000).batch(cfg.batch_size, drop_remainder=True)\n",
    "    return ds_train, ds_test"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [],
   "source": [
    "# 定义卷积神经网络，无正则化\n",
    "class ForwardFashion(nn.Cell):\n",
    "    def __init__(self, num_class=10):  # 一共分十类，图片通道数是1\n",
    "        super(ForwardFashion, self).__init__()\n",
    "        self.num_class = num_class\n",
    "        self.conv1 = nn.Conv2d(1, 32,kernel_size=3, stride=1, padding=0, has_bias=False, pad_mode=\"valid\")\n",
    "        self.conv2 = nn.Conv2d(32, 64,kernel_size=3, stride=1, padding=0, has_bias=False, pad_mode=\"valid\")\n",
    "        self.conv3 = nn.Conv2d(64, 128,kernel_size=3, stride=1, padding=0, has_bias=False, pad_mode=\"valid\")\n",
    "        self.maxpool2d = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.fc1 = nn.Dense(128 * 11 * 11, 128)\n",
    "        self.fc2 = nn.Dense(128, self.num_class)\n",
    "\n",
    "    def construct(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv3(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.maxpool2d(x)\n",
    "        x = self.flatten(x)\n",
    "        x = self.fc1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        return x"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [],
   "source": [
    "# 定义卷积神经网络，有正则化\n",
    "class ForwardFashionRegularization(nn.Cell):\n",
    "    def __init__(self, num_class=10):  # 一共分十类，图片通道数是1\n",
    "        super(ForwardFashionRegularization, self).__init__()\n",
    "        self.num_class = num_class\n",
    "        self.conv1 = nn.Conv2d(1, 32,kernel_size=3, stride=1, padding=0, has_bias=False, pad_mode=\"valid\")\n",
    "        self.conv2 = nn.Conv2d(32, 64,kernel_size=3, stride=1, padding=0, has_bias=False, pad_mode=\"valid\")\n",
    "        self.conv3 = nn.Conv2d(64, 128,kernel_size=3, stride=1, padding=0, has_bias=False, pad_mode=\"valid\")\n",
    "        self.maxpool2d = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.dropout = nn.Dropout()\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.fc1 = nn.Dense(3200, 128)\n",
    "        self.bn = nn.BatchNorm1d(128)\n",
    "        self.fc2 = nn.Dense(128, self.num_class)\n",
    "\n",
    "    def construct(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.maxpool2d(x)\n",
    "        x = self.dropout(x)\n",
    "        x = self.conv3(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.maxpool2d(x)\n",
    "        x = self.dropout(x)\n",
    "        x = self.flatten(x)\n",
    "        x = self.fc1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.bn(x)\n",
    "        x = self.dropout(x)\n",
    "        x = self.fc2(x)\n",
    "        return x"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [],
   "source": [
    "def train(Net):\n",
    "    ds_train, ds_test = create_dataset()\n",
    "    # 构建网络\n",
    "    network = Net(cfg.num_classes)\n",
    "    # 定义模型的损失函数，优化器\n",
    "    net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction=\"mean\")\n",
    "    net_opt = nn.Adam(network.trainable_params(), cfg.lr)\n",
    "    # 训练模型\n",
    "    model = Model(network, loss_fn=net_loss, optimizer=net_opt, metrics={'acc': Accuracy()})\n",
    "    loss_cb = LossMonitor()\n",
    "    print(\"============== Starting Training ==============\")\n",
    "    model.train(30, ds_train, callbacks=[loss_cb], dataset_sink_mode=True)\n",
    "    # 验证\n",
    "    metric = model.eval(ds_test)\n",
    "    print(metric)\n",
    "\n",
    "    return model"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============== Starting Training ==============\n",
      "epoch: 1 step: 937, loss is 0.4865747094154358\n",
      "epoch: 2 step: 937, loss is 0.23042701184749603\n",
      "epoch: 3 step: 937, loss is 0.4759939908981323\n",
      "epoch: 4 step: 937, loss is 0.275332510471344\n",
      "epoch: 5 step: 937, loss is 0.10672726482152939\n",
      "epoch: 6 step: 937, loss is 0.05795471742749214\n",
      "epoch: 7 step: 937, loss is 0.12320438772439957\n",
      "epoch: 8 step: 937, loss is 0.063594751060009\n",
      "epoch: 9 step: 937, loss is 0.060229506343603134\n",
      "epoch: 10 step: 937, loss is 0.08327358961105347\n",
      "epoch: 11 step: 937, loss is 0.0440383218228817\n",
      "epoch: 12 step: 937, loss is 0.03904265537858009\n",
      "epoch: 13 step: 937, loss is 0.010391742922365665\n",
      "epoch: 14 step: 937, loss is 0.22537042200565338\n",
      "epoch: 15 step: 937, loss is 0.0019592447206377983\n",
      "epoch: 16 step: 937, loss is 0.005871411878615618\n",
      "epoch: 17 step: 937, loss is 0.0007009106338955462\n",
      "epoch: 18 step: 937, loss is 0.012983396649360657\n",
      "epoch: 19 step: 937, loss is 0.06178334727883339\n",
      "epoch: 20 step: 937, loss is 0.1086501032114029\n",
      "epoch: 21 step: 937, loss is 0.0024169497191905975\n",
      "epoch: 22 step: 937, loss is 0.010459456592798233\n",
      "epoch: 23 step: 937, loss is 0.04862063750624657\n",
      "epoch: 24 step: 937, loss is 0.0024758747313171625\n",
      "epoch: 25 step: 937, loss is 0.009262202307581902\n",
      "epoch: 26 step: 937, loss is 0.12505030632019043\n",
      "epoch: 27 step: 937, loss is 0.0016393127152696252\n",
      "epoch: 28 step: 937, loss is 0.00046181416837498546\n",
      "epoch: 29 step: 937, loss is 0.01760275848209858\n",
      "epoch: 30 step: 937, loss is 0.05668973550200462\n",
      "{'acc': 0.9100560897435898}\n"
     ]
    }
   ],
   "source": [
    "# 训练无正则化的网络\n",
    "model = train(ForwardFashion)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第0个sample预测结果： 5    真实结果： 5\n",
      "第1个sample预测结果： 9    真实结果： 9\n",
      "第2个sample预测结果： 7    真实结果： 7\n",
      "第3个sample预测结果： 7    真实结果： 7\n",
      "第4个sample预测结果： 8    真实结果： 8\n",
      "第5个sample预测结果： 4    真实结果： 4\n",
      "第6个sample预测结果： 4    真实结果： 4\n",
      "第7个sample预测结果： 7    真实结果： 7\n",
      "第8个sample预测结果： 1    真实结果： 1\n",
      "第9个sample预测结果： 8    真实结果： 8\n",
      "第10个sample预测结果： 2    真实结果： 2\n",
      "第11个sample预测结果： 2    真实结果： 2\n",
      "第12个sample预测结果： 1    真实结果： 1\n",
      "第13个sample预测结果： 3    真实结果： 3\n",
      "第14个sample预测结果： 6    真实结果： 6\n"
     ]
    }
   ],
   "source": [
    "# 预测\n",
    "ds_test, _ = create_dataset()\n",
    "test_ = ds_test.create_dict_iterator(output_numpy=True).__next__()\n",
    "predictions = model.predict(Tensor(test_['x']))\n",
    "predictions = predictions.asnumpy()\n",
    "for i in range(15):\n",
    "    p_np = predictions[i, :]\n",
    "    p_list = p_np.tolist()\n",
    "    print('第' + str(i) + '个sample预测结果：', p_list.index(max(p_list)), '   真实结果：', test_['y'][i])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [],
   "source": [
    "# -------------------定义可视化函数--------------------------------\n",
    "# 输入预测结果序列，真实标签序列，以及图片序列\n",
    "# 目标是根据预测值对错，让其标签显示为红色或者蓝色。对：标签为红色；错：标签为蓝色\n",
    "def plot_image(predictions_array, true_label, img):\n",
    "    plt.grid(False)\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "    # 显示对应图片\n",
    "    plt.imshow(img, cmap=plt.cm.binary)\n",
    "    # 显示预测结果的颜色，如果对上了是蓝色，否则为红色\n",
    "    predicted_label = np.argmax(predictions_array)\n",
    "    if predicted_label == true_label:\n",
    "        color = 'blue'\n",
    "    else:\n",
    "        color = 'red'\n",
    "    # 显示对应标签的格式，样式\n",
    "    plt.xlabel('{},{:2.0f}% ({})'.format(class_names[predicted_label],\n",
    "                                         100 * np.max(predictions_array),\n",
    "                                         class_names[true_label]), color=color)\n",
    "# 将预测的结果以柱状图形状显示蓝对红错\n",
    "def plot_value_array(predictions_array, true_label):\n",
    "    plt.grid(False)\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "    this_plot = plt.bar(range(10), predictions_array, color='#777777')\n",
    "    plt.ylim([0, 1])\n",
    "    predicted_label = np.argmax(predictions_array)\n",
    "    this_plot[predicted_label].set_color('red')\n",
    "    this_plot[true_label].set_color('blue')\n",
    "\n",
    "import numpy as np\n",
    "def softmax_np(x):\n",
    "    x = x - np.max(x)\n",
    "    exp_x = np.exp(x)\n",
    "    softmax_x = exp_x/np.sum(exp_x)\n",
    "    return softmax_x"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 1200x1000 with 30 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 预测15个图像与标签，并展现出来\n",
    "num_rows = 5\n",
    "num_cols = 3\n",
    "num_images = num_rows * num_cols\n",
    "plt.figure(figsize=(2 * 2 * num_cols, 2 * num_rows))\n",
    "class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',\n",
    "               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']\n",
    "for i in range(num_images):\n",
    "    plt.subplot(num_rows, 2 * num_cols, 2 * i + 1)\n",
    "    pred_np_ = predictions[i, :]\n",
    "    pred_np_ = softmax_np(pred_np_)\n",
    "    plot_image(pred_np_, test_['y'][i], test_['x'][i, 0, ...])\n",
    "    plt.subplot(num_rows, 2 * num_cols, 2 * i + 2)\n",
    "    plot_value_array(pred_np_, test_['y'][i])\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}